package AbstractTests;

import static org.junit.Assert.assertTrue;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import Exceptions.PreCondException;
import Impl.Dir;
import Impl.Terrain;
import Impl.Type;
import Services.MoteurJeuService;
import Services.TerrainService;

public abstract class AbstractMoteurJeuServiceTest {
	private MoteurJeuService moteur;
	
	protected AbstractMoteurJeuServiceTest() {
		moteur = null;
	}
	
	protected final MoteurJeuService getMoteur() {
		return moteur;
	}
		
	protected final void setMoteur(MoteurJeuService moteur) {
		this.moteur = moteur;
	}

	@Before
	public abstract void beforeTests(); 

	@After
	public final void afterTests() {
		moteur = null;
	}
	
	@Test (expected = PreCondException.class)
	public void testPreInitFalse_1(){
		// Conditions Initiales
		TerrainService terrain = new Terrain();
		terrain.init(3, 3);
		terrain.addObject(1, 2, Type.Diamant);
		terrain.addObject(2, 2, Type.SortieFermee);
		terrain.startTerrain();
		
		// Operations
		moteur.init(0, terrain);
	}
	@Test (expected = PreCondException.class)
	public void testPreInitFalse_2(){
		// Conditions Initiales
		TerrainService terrain = new Terrain();
		terrain.init(3, 3);
		terrain.addObject(1, 2, Type.Diamant);
		terrain.addObject(2, 2, Type.SortieFermee);
		terrain.startTerrain();
		
		// Operations
		moteur.init(-5, terrain);
	}
	@Test (expected = PreCondException.class)
	public void testPreInitFalse_3(){
		// Conditions Initiales
		TerrainService terrain = new Terrain();
		terrain.init(3, 3);
		
		// Operations
		moteur.init(2, terrain);
	}
	@Test
	public void testPreInitTrue_1(){
		// Conditions Initiales
		TerrainService terrain = new Terrain();
		terrain.init(3, 3);
		terrain.addObject(1, 2, Type.Diamant);
		terrain.addObject(2, 2, Type.SortieFermee);
		terrain.startTerrain();
		
		
		// Operations
		try{
			moteur.init(1, terrain);
		}catch (PreCondException e) {
			assertTrue(false); return;
		}assertTrue(true);
		
	}
	@Test
	public void testPostInit_1(){
		// Conditions Initiales
		TerrainService terrain = new Terrain();
		terrain.init(3, 3);
		terrain.addObject(1, 2, Type.Diamant);
		terrain.addObject(2, 2, Type.SortieFermee);
		terrain.startTerrain();
		
		// Operations
		moteur.init(5, terrain);
		
		assertTrue(moteur.estFinie()==false);
		assertTrue(moteur.estGagne()==false);
		assertTrue(moteur.haveHeroMove()==false);
		assertTrue(moteur.haveObjectMove()==false);
		assertTrue(moteur.getPasRestants()==5);
		assertTrue(moteur.getTerrain().equals(terrain));
	}

	@Test
	public void testPreVerifFalse_1(){
		// TODO unreachable !estFinie() ne peut etre faux et les autres vraies
	}
	@Test (expected = PreCondException.class)
	public void testPreVerifFalse_2(){
		TerrainService terrain = new Terrain();
		terrain.init(3, 3);
		terrain.addObject(1, 2, Type.Diamant);
		terrain.addObject(2, 2, Type.SortieFermee);
		terrain.startTerrain();
		moteur.init(5, terrain);
		moteur.moveHero(Dir.Droite);
		
		moteur.verif();
	}
	@Test
	public void testPreVerifFalse_3(){
		// TODO unreachable on ne peut pas avoir haveObjectMove et non haveHeroMove
	}
	@Test
	public void testPreVerifTrue_1(){
		TerrainService terrain = new Terrain();
		terrain.init(3, 3);
		terrain.addObject(1, 2, Type.Diamant);
		terrain.addObject(2, 2, Type.SortieFermee);
		terrain.startTerrain();
		moteur.init(5, terrain);
		moteur.moveHero(Dir.Bas);
		moteur.moveObjects();
		
		try{
			moteur.verif();
		}catch (PreCondException e) {
			assertTrue(false); return;
		}assertTrue(true);
	}
	// TODO seb manque un cas de postverif
	@Test
	public void testPostVerif_1(){
		TerrainService terrain = new Terrain();
		terrain.init(3, 3);
		terrain.addObject(1, 2, Type.Diamant);
		terrain.addObject(2, 2, Type.SortieFermee);
		terrain.startTerrain();
		moteur.init(5, terrain);
		moteur.moveHero(Dir.Bas);
		moteur.moveObjects();
		
		TerrainService terrainAtPre = new Terrain();
		terrainAtPre.clone(terrain);
		boolean estFinieAtPre = moteur.estFinie();
		boolean estGagneAtPre = moteur.estGagne();
		int getPasRestantsAtPre = moteur.getPasRestants();
		
		moteur.verif();
		
		assertTrue(moteur.getPasRestants()==getPasRestantsAtPre);
		
		terrainAtPre.openDoor();
		assertTrue(moteur.getTerrain().equals(terrainAtPre));
		assertTrue(moteur.estFinie()==estFinieAtPre && moteur.estGagne()==estGagneAtPre);
		assertTrue(moteur.haveHeroMove()==false);
		assertTrue(moteur.haveObjectMove()==false);
	}
	@Test
	public void testPostVerif_2(){
		TerrainService terrain = new Terrain();
		terrain.init(3, 3);
		terrain.addObject(1, 2, Type.Diamant);
		terrain.addObject(2, 2, Type.SortieFermee);
		terrain.startTerrain();
		moteur.init(5, terrain);
		moteur.moveHero(Dir.Droite);
		moteur.moveObjects();
		
		TerrainService terrainAtPre = new Terrain();
		terrainAtPre.clone(terrain);
		boolean estFinieAtPre = moteur.estFinie();
		boolean estGagneAtPre = moteur.estGagne();
		int getPasRestantsAtPre = moteur.getPasRestants();
		
		moteur.verif();
		
		assertTrue(moteur.getPasRestants()==getPasRestantsAtPre);	
		assertTrue(moteur.getTerrain().equals(terrainAtPre));
		assertTrue(moteur.estFinie()==estFinieAtPre && moteur.estGagne()==estGagneAtPre);
		assertTrue(moteur.haveHeroMove()==false);
		assertTrue(moteur.haveObjectMove()==false);
	}
	@Test
	public void testPostVerif_3(){
		TerrainService terrain = new Terrain();
		terrain.init(3, 3);
		terrain.addObject(1, 2, Type.Diamant);
		terrain.addObject(2, 2, Type.SortieFermee);
		terrain.startTerrain();
		moteur.init(5, terrain);
		moteur.moveHero(Dir.Bas);
		moteur.moveObjects();
		moteur.verif();
		moteur.moveHero(Dir.Droite);
		moteur.moveObjects();
		
		TerrainService terrainAtPre = new Terrain();
		terrainAtPre.clone(terrain);
		int getPasRestantsAtPre = moteur.getPasRestants();
		
		moteur.verif();
		
		assertTrue(moteur.getPasRestants()==getPasRestantsAtPre);
		assertTrue(moteur.getTerrain().equals(terrainAtPre));		
		assertTrue(moteur.estFinie()==true && moteur.estGagne()==true );
		assertTrue(moteur.haveHeroMove()==false);
		assertTrue(moteur.haveObjectMove()==false);
	}
	@Test
	public void testPostVerif_4(){
		TerrainService terrain = new Terrain();
		terrain.init(3, 3);
		terrain.addObject(1, 2, Type.Diamant);
		terrain.addObject(2, 2, Type.SortieFermee);
		terrain.startTerrain();
		moteur.init(5, terrain);
		moteur.moveHero(Dir.Haut);
		moteur.moveObjects();
		
		TerrainService terrainAtPre = new Terrain();
		terrainAtPre.clone(terrain);
		int getPasRestantsAtPre = moteur.getPasRestants();
		
		moteur.verif();
		
		assertTrue(moteur.getPasRestants()==getPasRestantsAtPre);
		assertTrue(moteur.getTerrain().equals(terrainAtPre));		
		assertTrue(moteur.estFinie()==true && moteur.estGagne()==false );
		assertTrue(moteur.haveHeroMove()==false);
		assertTrue(moteur.haveObjectMove()==false);
	}

	@Test
	public void testPreMoveObjectsFalse_1(){
		// TODO unreachable on ne peut pas avoir !estFinie() et haveHeroMove
	}
	@Test (expected = PreCondException.class)
	public void testPreMoveObjectsFalse_2(){
		TerrainService terrain = new Terrain();
		terrain.init(3, 3);
		terrain.addObject(1, 2, Type.Diamant);
		terrain.addObject(2, 2, Type.SortieFermee);
		terrain.startTerrain();
		moteur.init(5, terrain);
		
		moteur.moveObjects();
	}
	@Test (expected = PreCondException.class)
	public void testPreMoveObjectsFalse_3(){
		TerrainService terrain = new Terrain();
		terrain.init(3, 3);
		terrain.addObject(1, 2, Type.Diamant);
		terrain.addObject(2, 2, Type.SortieFermee);
		terrain.startTerrain();
		moteur.init(5, terrain);
		moteur.moveHero(Dir.Droite);
		moteur.moveObjects();
		
		moteur.moveObjects();
	}
	@Test
	public void testPreMoveObjectsTrue_1(){
		TerrainService terrain = new Terrain();
		terrain.init(3, 3);
		terrain.addObject(1, 2, Type.Diamant);
		terrain.addObject(2, 2, Type.SortieFermee);
		terrain.startTerrain();
		moteur.init(5, terrain);
		moteur.moveHero(Dir.Droite);
		
		try{
			moteur.moveObjects();
		}catch (PreCondException e) {
			assertTrue(false); return;
		}assertTrue(true);
	}
	@Test
	public void testPostMoveObjects_1(){
		TerrainService terrain = new Terrain();
		terrain.init(3, 3);
		terrain.addObject(1, 2, Type.Diamant);
		terrain.addObject(2, 2, Type.SortieFermee);
		terrain.startTerrain();
		moteur.init(5, terrain);
		moteur.moveHero(Dir.Droite);
		
		boolean estFinieAtPre = moteur.estFinie();
		boolean estGagneAtPre = moteur.estGagne();
		boolean haveHeroMoveAtPre = moteur.haveHeroMove();
		int getPasRestantsAtPre = moteur.getPasRestants();
		TerrainService terrainAtPre = moteur.getTerrain();
		
		moteur.moveObjects();
		
		assertTrue(moteur.estFinie()==estFinieAtPre);
		assertTrue(moteur.estGagne()==estGagneAtPre);
		assertTrue(moteur.getPasRestants()==getPasRestantsAtPre);
		assertTrue(moteur.haveHeroMove()==haveHeroMoveAtPre);
		assertTrue(moteur.haveObjectMove()==true);
		
		for(int x=1; x<=terrainAtPre.getSizeX(); x++)
			for(int y=1; y<=terrainAtPre.getSizeY(); y++)
				if(terrainAtPre.getTypeBloc(x, y)==Type.Rocher || terrainAtPre.getTypeBloc(x, y)==Type.Diamant)
					if((!terrainAtPre.isChanged(x, y)) && (terrainAtPre.getTypeBloc(x, y+1)==Type.Vide||terrainAtPre.getTypeBloc(x, y+1)==Type.Hero))
						terrainAtPre.moveObject(x, y, x, y+1);
		terrainAtPre.validate();
		
		assertTrue(terrainAtPre.equals(moteur.getTerrain()));
	}

	@Test (expected = PreCondException.class)
	public void testPreMoveHeroFalse_1(){
		TerrainService terrain = new Terrain();
		terrain.init(3, 3);
		terrain.addObject(1, 2, Type.Diamant);
		terrain.addObject(2, 2, Type.SortieFermee);
		terrain.startTerrain();
		moteur.init(5, terrain);
		moteur.moveHero(Dir.Bas);
		moteur.moveObjects();
		moteur.verif();
		moteur.moveHero(Dir.Droite);
		moteur.moveObjects();
		moteur.verif();
		
		moteur.moveHero(Dir.Gauche);
	}
	@Test (expected = PreCondException.class)
	public void testPreMoveHeroFalse_2(){
		TerrainService terrain = new Terrain();
		terrain.init(3, 3);
		terrain.addObject(1, 2, Type.Diamant);
		terrain.addObject(2, 2, Type.SortieFermee);
		terrain.startTerrain();
		moteur.init(5, terrain);
		moteur.moveHero(Dir.Bas);
		moteur.moveObjects();
		
		moteur.moveHero(Dir.Gauche);
	}
	@Test (expected = PreCondException.class)
	public void testPreMoveHeroFalse_3(){
		TerrainService terrain = new Terrain();
		terrain.init(3, 3);
		terrain.addObject(1, 2, Type.Diamant);
		terrain.addObject(2, 2, Type.SortieFermee);
		terrain.startTerrain();
		moteur.init(5, terrain);
		moteur.moveHero(Dir.Bas);
		
		moteur.moveHero(Dir.Gauche);
	}
	@Test
	public void testPreMoveHeroTrue_1(){
		TerrainService terrain = new Terrain();
		terrain.init(3, 3);
		terrain.addObject(1, 2, Type.Diamant);
		terrain.addObject(2, 2, Type.SortieFermee);
		terrain.startTerrain();
		moteur.init(5, terrain);
		
		try{
			moteur.moveHero(Dir.Gauche);
		}catch (PreCondException e) {
			assertTrue(false); return;
		}assertTrue(true);
	}
	// GAUCHE
	@Test
	public void testPostMoveHero_1(){
		TerrainService terrain = new Terrain();
		terrain.init(3, 3);
		terrain.addObject(1, 2, Type.Diamant);
		terrain.addObject(2, 2, Type.SortieFermee);
		terrain.startTerrain();
		moteur.init(5, terrain);
		
		boolean estFinieAtPre = moteur.estFinie();
		boolean estGagneAtPre = moteur.estGagne();
		boolean haveObjectMoveAtPre = moteur.haveObjectMove();
		int getPasRestantsAtPre = moteur.getPasRestants();
		TerrainService terrainAtPre = new Terrain();
		terrainAtPre.clone(terrain);
		int xJoueurAtPre = terrainAtPre.getXJoueur();
		int yJoueurAtPre = terrainAtPre.getYJoueur();
		
		moteur.moveHero(Dir.Gauche);
		
		assertTrue(moteur.estFinie()==estFinieAtPre);
		assertTrue(moteur.estGagne()==estGagneAtPre);
		assertTrue(moteur.getPasRestants()==getPasRestantsAtPre-1);
		assertTrue(moteur.haveHeroMove()==true);
		assertTrue(moteur.haveObjectMove()==haveObjectMoveAtPre);
		terrainAtPre.putHero(xJoueurAtPre-1, yJoueurAtPre);
		assertTrue(moteur.getTerrain().equals(terrainAtPre));
	}
	@Test
	public void testPostMoveHero_2(){
		TerrainService terrain = new Terrain();
		terrain.init(3, 3);
		terrain.addObject(3, 1, Type.Rocher);
		terrain.addObject(3, 2, Type.Diamant);
		terrain.addObject(2, 2, Type.SortieFermee);
		terrain.startTerrain();
		moteur.init(5, terrain);
		
		boolean estFinieAtPre = moteur.estFinie();
		boolean estGagneAtPre = moteur.estGagne();
		boolean haveObjectMoveAtPre = moteur.haveObjectMove();
		int getPasRestantsAtPre = moteur.getPasRestants();
		TerrainService terrainAtPre = new Terrain();
		terrainAtPre.clone(terrain);
		int xJoueurAtPre = terrainAtPre.getXJoueur();
		int yJoueurAtPre = terrainAtPre.getYJoueur();
		
		moteur.moveHero(Dir.Gauche);
		
		assertTrue(moteur.estFinie()==estFinieAtPre);
		assertTrue(moteur.estGagne()==estGagneAtPre);
		assertTrue(moteur.getPasRestants()==getPasRestantsAtPre-1);
		assertTrue(moteur.haveHeroMove()==true);
		assertTrue(moteur.haveObjectMove()==haveObjectMoveAtPre);
		
		terrainAtPre.moveObject(xJoueurAtPre-1, yJoueurAtPre, xJoueurAtPre-2, yJoueurAtPre);
		terrainAtPre.putHero(xJoueurAtPre-1, yJoueurAtPre);
		assertTrue(moteur.getTerrain().equals(terrainAtPre));
	}
	@Test
	public void testPostMoveHero_3(){
		TerrainService terrain = new Terrain();
		terrain.init(3, 3);
		terrain.addObject(3, 1, Type.Mur);
		terrain.addObject(3, 2, Type.Diamant);
		terrain.addObject(2, 2, Type.SortieFermee);
		terrain.startTerrain();
		moteur.init(5, terrain);
		
		boolean estFinieAtPre = moteur.estFinie();
		boolean estGagneAtPre = moteur.estGagne();
		boolean haveObjectMoveAtPre = moteur.haveObjectMove();
		int getPasRestantsAtPre = moteur.getPasRestants();
		TerrainService terrainAtPre = new Terrain();
		terrainAtPre.clone(terrain);
		
		moteur.moveHero(Dir.Gauche);
		
		assertTrue(moteur.estFinie()==estFinieAtPre);
		assertTrue(moteur.estGagne()==estGagneAtPre);
		assertTrue(moteur.getPasRestants()==getPasRestantsAtPre-1);
		assertTrue(moteur.haveHeroMove()==true);
		assertTrue(moteur.haveObjectMove()==haveObjectMoveAtPre);
		assertTrue(moteur.getTerrain().equals(terrainAtPre));
	}
	// DROITE
	@Test
	public void testPostMoveHero_4(){
		TerrainService terrain = new Terrain();
		terrain.init(3, 3);
		terrain.addObject(1, 2, Type.Diamant);
		terrain.addObject(2, 2, Type.SortieFermee);
		terrain.startTerrain();
		moteur.init(5, terrain);
		
		boolean estFinieAtPre = moteur.estFinie();
		boolean estGagneAtPre = moteur.estGagne();
		boolean haveObjectMoveAtPre = moteur.haveObjectMove();
		int getPasRestantsAtPre = moteur.getPasRestants();
		TerrainService terrainAtPre = new Terrain();
		terrainAtPre.clone(terrain);
		int xJoueurAtPre = terrainAtPre.getXJoueur();
		int yJoueurAtPre = terrainAtPre.getYJoueur();
		
		moteur.moveHero(Dir.Droite);
		
		assertTrue(moteur.estFinie()==estFinieAtPre);
		assertTrue(moteur.estGagne()==estGagneAtPre);
		assertTrue(moteur.getPasRestants()==getPasRestantsAtPre-1);
		assertTrue(moteur.haveHeroMove()==true);
		assertTrue(moteur.haveObjectMove()==haveObjectMoveAtPre);
		
		terrainAtPre.putHero(xJoueurAtPre+1, yJoueurAtPre);
		assertTrue(moteur.getTerrain().equals(terrainAtPre));
	}
	@Test
	public void testPostMoveHero_5(){
		TerrainService terrain = new Terrain();
		terrain.init(3, 3);
		terrain.addObject(2, 1, Type.Rocher);
		terrain.addObject(3, 2, Type.Diamant);
		terrain.addObject(2, 2, Type.SortieFermee);
		terrain.startTerrain();
		moteur.init(5, terrain);
		
		boolean estFinieAtPre = moteur.estFinie();
		boolean estGagneAtPre = moteur.estGagne();
		boolean haveObjectMoveAtPre = moteur.haveObjectMove();
		int getPasRestantsAtPre = moteur.getPasRestants();
		TerrainService terrainAtPre = new Terrain();
		terrainAtPre.clone(terrain);
		int xJoueurAtPre = terrainAtPre.getXJoueur();
		int yJoueurAtPre = terrainAtPre.getYJoueur();
		
		moteur.moveHero(Dir.Droite);
		
		assertTrue(moteur.estFinie()==estFinieAtPre);
		assertTrue(moteur.estGagne()==estGagneAtPre);
		assertTrue(moteur.getPasRestants()==getPasRestantsAtPre-1);
		assertTrue(moteur.haveHeroMove()==true);
		assertTrue(moteur.haveObjectMove()==haveObjectMoveAtPre);
		
		terrainAtPre.moveObject(xJoueurAtPre+1, yJoueurAtPre, xJoueurAtPre+2, yJoueurAtPre);
		terrainAtPre.putHero(xJoueurAtPre+1, yJoueurAtPre);
		assertTrue(moteur.getTerrain().equals(terrainAtPre));
	}
	@Test
	public void testPostMoveHero_6(){
		TerrainService terrain = new Terrain();
		terrain.init(3, 3);
		terrain.addObject(2, 1, Type.Mur);
		terrain.addObject(3, 2, Type.Diamant);
		terrain.addObject(2, 2, Type.SortieFermee);
		terrain.startTerrain();
		moteur.init(5, terrain);
		
		boolean estFinieAtPre = moteur.estFinie();
		boolean estGagneAtPre = moteur.estGagne();
		boolean haveObjectMoveAtPre = moteur.haveObjectMove();
		int getPasRestantsAtPre = moteur.getPasRestants();
		TerrainService terrainAtPre = new Terrain();
		terrainAtPre.clone(terrain);

		
		moteur.moveHero(Dir.Droite);
		
		assertTrue(moteur.estFinie()==estFinieAtPre);
		assertTrue(moteur.estGagne()==estGagneAtPre);
		assertTrue(moteur.getPasRestants()==getPasRestantsAtPre-1);
		assertTrue(moteur.haveHeroMove()==true);
		assertTrue(moteur.haveObjectMove()==haveObjectMoveAtPre);
		assertTrue(moteur.getTerrain().equals(terrainAtPre));
	}
	// HAUT
	@Test
	public void testPostMoveHero_7(){
		TerrainService terrain = new Terrain();
		terrain.init(3, 3);
		terrain.addObject(1, 2, Type.Diamant);
		terrain.addObject(2, 2, Type.SortieFermee);
		terrain.startTerrain();
		moteur.init(5, terrain);
		
		boolean estFinieAtPre = moteur.estFinie();
		boolean estGagneAtPre = moteur.estGagne();
		boolean haveObjectMoveAtPre = moteur.haveObjectMove();
		int getPasRestantsAtPre = moteur.getPasRestants();
		TerrainService terrainAtPre = new Terrain();
		terrainAtPre.clone(terrain);
		int xJoueurAtPre = terrainAtPre.getXJoueur();
		int yJoueurAtPre = terrainAtPre.getYJoueur();
		
		moteur.moveHero(Dir.Haut);
		
		assertTrue(moteur.estFinie()==estFinieAtPre);
		assertTrue(moteur.estGagne()==estGagneAtPre);
		assertTrue(moteur.getPasRestants()==getPasRestantsAtPre-1);
		assertTrue(moteur.haveHeroMove()==true);
		assertTrue(moteur.haveObjectMove()==haveObjectMoveAtPre);
		
		terrainAtPre.putHero(xJoueurAtPre, yJoueurAtPre-1);
		assertTrue(moteur.getTerrain().equals(terrainAtPre));
	}
	@Test
	public void testPostMoveHero_8(){
		TerrainService terrain = new Terrain();
		terrain.init(3, 3);
		terrain.addObject(1, 3, Type.Rocher);
		terrain.addObject(3, 2, Type.Diamant);
		terrain.addObject(2, 2, Type.SortieFermee);
		terrain.startTerrain();
		moteur.init(5, terrain);
		
		boolean estFinieAtPre = moteur.estFinie();
		boolean estGagneAtPre = moteur.estGagne();
		boolean haveObjectMoveAtPre = moteur.haveObjectMove();
		int getPasRestantsAtPre = moteur.getPasRestants();
		TerrainService terrainAtPre = new Terrain();
		terrainAtPre.clone(terrain);
		
		moteur.moveHero(Dir.Haut);
		
		assertTrue(moteur.estFinie()==estFinieAtPre);
		assertTrue(moteur.estGagne()==estGagneAtPre);
		assertTrue(moteur.getPasRestants()==getPasRestantsAtPre-1);
		assertTrue(moteur.haveHeroMove()==true);
		assertTrue(moteur.haveObjectMove()==haveObjectMoveAtPre);
		assertTrue(moteur.getTerrain().equals(terrainAtPre));
	}
	// BAS
	@Test
	public void testPostMoveHero_9(){
		TerrainService terrain = new Terrain();
		terrain.init(3, 3);
		terrain.addObject(1, 2, Type.Diamant);
		terrain.addObject(2, 2, Type.SortieFermee);
		terrain.startTerrain();
		moteur.init(5, terrain);
		
		boolean estFinieAtPre = moteur.estFinie();
		boolean estGagneAtPre = moteur.estGagne();
		boolean haveObjectMoveAtPre = moteur.haveObjectMove();
		int getPasRestantsAtPre = moteur.getPasRestants();
		TerrainService terrainAtPre = new Terrain();
		terrainAtPre.clone(terrain);
		int xJoueurAtPre = terrainAtPre.getXJoueur();
		int yJoueurAtPre = terrainAtPre.getYJoueur();
		
		moteur.moveHero(Dir.Bas);
		
		assertTrue(moteur.estFinie()==estFinieAtPre);
		assertTrue(moteur.estGagne()==estGagneAtPre);
		assertTrue(moteur.getPasRestants()==getPasRestantsAtPre-1);
		assertTrue(moteur.haveHeroMove()==true);
		assertTrue(moteur.haveObjectMove()==haveObjectMoveAtPre);
		
		terrainAtPre.putHero(xJoueurAtPre, yJoueurAtPre+1);
		assertTrue(moteur.getTerrain().equals(terrainAtPre));
	}
	@Test
	public void testPostMoveHero_10(){
		TerrainService terrain = new Terrain();
		terrain.init(3, 3);
		terrain.addObject(1, 2, Type.Mur);
		terrain.addObject(3, 2, Type.Diamant);
		terrain.addObject(2, 2, Type.SortieFermee);
		terrain.startTerrain();
		moteur.init(5, terrain);
		
		boolean estFinieAtPre = moteur.estFinie();
		boolean estGagneAtPre = moteur.estGagne();
		boolean haveObjectMoveAtPre = moteur.haveObjectMove();
		int getPasRestantsAtPre = moteur.getPasRestants();
		TerrainService terrainAtPre = new Terrain();
		terrainAtPre.clone(terrain);
		
		moteur.moveHero(Dir.Bas);
		
		assertTrue(moteur.estFinie()==estFinieAtPre);
		assertTrue(moteur.estGagne()==estGagneAtPre);
		assertTrue(moteur.getPasRestants()==getPasRestantsAtPre-1);
		assertTrue(moteur.haveHeroMove()==true);
		assertTrue(moteur.haveObjectMove()==haveObjectMoveAtPre);
		assertTrue(moteur.getTerrain().equals(terrainAtPre));
	}
	// RIEN
	@Test
	public void testPostMoveHero_11(){
		TerrainService terrain = new Terrain();
		terrain.init(3, 3);
		terrain.addObject(1, 2, Type.Mur);
		terrain.addObject(3, 2, Type.Diamant);
		terrain.addObject(2, 2, Type.SortieFermee);
		terrain.startTerrain();
		moteur.init(5, terrain);
		
		boolean estFinieAtPre = moteur.estFinie();
		boolean estGagneAtPre = moteur.estGagne();
		boolean haveObjectMoveAtPre = moteur.haveObjectMove();
		int getPasRestantsAtPre = moteur.getPasRestants();
		TerrainService terrainAtPre = new Terrain();
		terrainAtPre.clone(terrain);
		
		moteur.moveHero(Dir.Rien);
		
		assertTrue(moteur.estFinie()==estFinieAtPre);
		assertTrue(moteur.estGagne()==estGagneAtPre);
		// TODO a modifier dans les objectifs de test
		assertTrue(moteur.getPasRestants()==getPasRestantsAtPre-1);
		assertTrue(moteur.haveHeroMove()==true);
		assertTrue(moteur.haveObjectMove()==haveObjectMoveAtPre);
		assertTrue(moteur.getTerrain().equals(terrainAtPre));
	}

	@Test
	public void testInv_1(){
		TerrainService terrain = new Terrain();
		terrain.init(3, 3);
		terrain.addObject(1, 2, Type.Diamant);
		terrain.addObject(2, 2, Type.SortieFermee);
		terrain.startTerrain();
		
		moteur.init(5, terrain);
		
		assertTrue(moteur.getPasRestants()>=0);
	}
	@Test
	public void testInv_2(){
		TerrainService terrain = new Terrain();
		terrain.init(3, 3);
		terrain.addObject(1, 2, Type.Diamant);
		terrain.addObject(2, 2, Type.SortieFermee);
		terrain.startTerrain();
		moteur.init(5, terrain);
		
		moteur.moveHero(Dir.Droite);
		
		assertTrue(moteur.getPasRestants()>=0);
	}
	@Test
	public void testInv_3(){
		TerrainService terrain = new Terrain();
		terrain.init(3, 3);
		terrain.addObject(1, 2, Type.Diamant);
		terrain.addObject(2, 2, Type.SortieFermee);
		terrain.startTerrain();
		moteur.init(5, terrain);
		moteur.moveHero(Dir.Droite);
		
		moteur.moveObjects();
		
		assertTrue(moteur.getPasRestants()>=0);
	}
	@Test
	public void testInv_4(){
		TerrainService terrain = new Terrain();
		terrain.init(3, 3);
		terrain.addObject(1, 2, Type.Diamant);
		terrain.addObject(2, 2, Type.SortieFermee);
		terrain.startTerrain();
		moteur.init(5, terrain);
		moteur.moveHero(Dir.Droite);
		moteur.moveObjects();
		
		moteur.verif();
		
		assertTrue(moteur.getPasRestants()>=0);
	}

}
